package com.browsesoft.user;

import java.io.Serializable;
import java.sql.SQLException;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.LinkedList;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.browsesoft.EntityManager;
import com.browsesoft.ManagerGroup;
import com.browsesoft.SequenceFind;
import com.browsesoft.dbtools.DBTools;
import com.browsesoft.htmlcomponent.HTMLBasicComponent;
import com.browsesoft.htmlcomponent.HTMLFormModel;
import com.browsesoft.resource.BasicResource;

/**
 * 功能模块类
 * 
 * @author Browsesoft
 * @version 1.0
 */
public class Function extends BasicResource implements HTMLFormModel,
		Serializable {
	/**
	 * 
	 */
	private static final long serialVersionUID = -3568964553134424971L;

	/**
	 * 功能模块对应的角色
	 */
	protected LinkedList roles = new LinkedList();

	/**
	 * 功能模块拥有子功能模块
	 */
	public LinkedList childFunctions = new LinkedList();

	/**
	 * 空构造函数
	 */
	public Function() {
		super();
	}

	/**
	 * 初始化model
	 * 
	 * @throws Exception
	 */
	public void init(HttpServletRequest request) throws Exception {
	}

	/**
	 * 使用属性构造
	 */
	public Function(Hashtable attrs) {
		super(attrs);
	}

	/**
	 * 更改功能属性
	 * 
	 */
	public void update() throws Exception {
		try {
			DBTools.update("T_function", getID(), attributes);
		} catch (SQLException e) {
			throw e;
		}
	}

	public void setParentID(String parentid) {
		this.parentID = parentid;
		
	}
	/**
	 * 得到子功能模块
	 * 
	 * @return 子功能列表
	 */
	// public LinkedList getFunctions() {
	// childFunctions = this.getChildFunctions();
	// for (int i = 0; i < childFunctions.size(); i++) {
	// Function function = (Function) childFunctions.get(i);
	// String location = (String) function.getAttributes().get("location");
	// // 如果没有位置location属性，则则按顺序添加
	// if (location == null || location.equals("")) {
	// function.getAttributes().put("location", Integer.toString(i));
	// }
	// }
	// // 将所有子功能按location排序
	// sort(childFunctions);
	// return childFunctions;
	// }
	// public LinkedList getChildFunctions() {
	// LinkedList list = new LinkedList();
	// for (int i = 0; i < children.size(); i++) {
	// Resource res = (Resource) children.get(i);
	// if (res.getType().equals("function")) {
	// list.add(res);
	// }
	// }
	// return list;
	// }
	//
	/**
	 * 根据位置给功能排序
	 */
	public static void sort(LinkedList childFunctions) {
		int length = childFunctions.size();
		int location = Integer.MAX_VALUE;
		int index = 0;
		for (int i = 0; i < length; i++) {
			for (int j = i; j < length; j++) {
				Function function = (Function) childFunctions.get(j);
				int l = function.getPosition();
				if (l < location) {
					index = j;
					location = l;
				}
			}
			location = Integer.MAX_VALUE;
			Function f = (Function) childFunctions.get(i);
			childFunctions.set(i, (Function) childFunctions.get(index));
			Function add = (Function) childFunctions.get(i);
			add.setPosition(i);
			childFunctions.set(index, f);
		}
	}

	/**
	 * 在功能firse后面增加功能second
	 * 
	 * @param first
	 * @param second
	 */
	// public void add(Function first, Function second) {
	// int location = first.getPosition();
	// childFunctions = this.getChildFunctions();
	// for (int i = 0; i < this.childFunctions.size(); i++) {
	// Function fun = (Function) childFunctions.get(i);
	// int funLocation = fun.getPosition();
	// // 将比first的location属性值大的功能的location属性值递增
	// if (location < funLocation) {
	// fun.setPosition(funLocation);
	// }
	// }
	// second.setPosition(location + 1);
	// // 增加功能
	// this.addChild(second);
	// // 子功能设置父功能
	// second.setParent(this);
	// }
	/**
	 * 删除子功能模块机构（装载）
	 * 
	 */
	public void remove(Function function) {
		childFunctions.remove(function);
	}

	/**
	 * 增加功能
	 */
	public void insert(Function func) throws Exception {
		Hashtable ht = new Hashtable();
		// 设置序列号
		String id = Integer.toString(SequenceFind.getID());
		ht.put("id", id);
		// 设置功能所属的父功能
		String parentid = this.getID();
		ht.put("parentid", parentid);
		// 增加属性
		func.getAttributes().putAll(ht);
		// 写库
		try {
			DBTools.insert("T_function", func.getAttributes());
		} catch (SQLException e) {
			// 取消本次操作
			throw e;
		}
		// 在管理器, 功能列表，父功能中增加功能
		this.addChild(func);
		EntityManager.getInstance().add(func);
	}

	/**
	 * 增加组织 (自己)
	 */
//	public void insert() throws Exception {
//	}

	/**
	 * 增加角色
	 * 
	 */
	public void add(Role role) {
		roles.add(role);
	}

	/**
	 * 删除角色
	 * 
	 */
	public void remove(Role role) {
		roles.remove(role);
	}

	/**
	 * 得到功能模块的角色
	 * 
	 * @return 角色列表
	 */
	public LinkedList getRoles() {
		return roles;
	}

	/**
	 * 看功能是否叶子节点
	 */
	public boolean isLeaf() {
		return this.childFunctions.size() == 0;
	}

	/**
	 * 设置功能模块属性
	 * 
	 */
	public void updateAttributes(Hashtable attrs) throws Exception {
		// 有parentid，说明是插入
		if (parentID != null) {
			EntityManager entitymanager = (EntityManager) ManagerGroup
					.getManagerGroup().getManager("entity");
			Function parent = (Function) entitymanager.getObject(parentID);
			parent.insert(this);
			parentID = null;
		}
		// 修改link
		String link = (String) attrs.get("link");
		// 是选择了流程
		if (link != null && link.indexOf('.') == -1) {
			link = "startProcess.jsp?processName=" + link;
			attrs.put("link", link);
		}
		this.attributes.putAll(attrs);
		this.update();
	}

	/**
	 * 取得选项值列表
	 */
	public Iterator getOptions(String selectName) throws Exception {
		throw new UnsupportedOperationException();
	}

	/**
	 * 记录客户端环境
	 * 
	 * @param request
	 */
	public void service(HttpServletRequest request, HttpServletResponse response)
			throws Exception {
		if (parentID == null) {
			parentID = request.getParameter("parentid");
		}
	}

	/**
	 * 设置模型所对应的组件
	 * 
	 * @param component
	 *            对应的组件
	 */
	public void setComponent(HTMLBasicComponent component) {
	}

	/**
	 * 模型更新页面元素
	 * 
	 * @throws Exception
	 */
	public void updatePageElement(HTMLBasicComponent c) throws Exception {
	}

	public void createRelation() {
	}

	public String getTableName() {
		return "T_function";
	}

	
}